home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / PInterfaces / FSM.p < prev    next >
Text File  |  1996-05-01  |  33KB  |  884 lines
  1. {
  2.      File:        FSM.p
  3.  
  4.      Contains:    HFS External File System Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT FSM;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __FSM__}
  28. {$SETC __FSM__ := 1}
  29.  
  30. {$I+}
  31. {$SETC FSMIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __FILES__}
  35. {$I Files.p}
  36. {$ENDC}
  37.  
  38. {$PUSH}
  39. {$ALIGN MAC68K}
  40. {$LibExport+}
  41.  
  42. {$IFC FOR_SYSTEM7_ONLY }
  43. {$IFC OLDROUTINELOCATIONS }
  44. {
  45.  * gestaltFSMVersion should be in Gestalt.h
  46.  *
  47.  * VCBPtr, new volume mount flags, and VolumeMountInfoHeader
  48.  * should be in Files.h
  49. }
  50. {     The new volume mount flags  }
  51.  
  52. CONST
  53.     volMountInteractBit            = 15;                            {  Input to VolumeMount: If set, it's OK for the file system  }
  54.     volMountInteractMask        = $8000;                        {  to perform user interaction to mount the volume  }
  55.     volMountChangedBit            = 14;                            {  Output from VoumeMount: If set, the volume was mounted, but  }
  56.     volMountChangedMask            = $4000;                        {  the volume mounting information record needs to be updated.  }
  57.     volMountFSReservedMask        = $00FF;                        {  bits 0-7 are defined by each file system for its own use  }
  58.     volMountSysReservedMask        = $FF00;                        {  bits 8-15 are reserved for Apple system use  }
  59.  
  60. {
  61.  * additional volume mount info record
  62. }
  63.  
  64. TYPE
  65.     VolumeMountInfoHeaderPtr = ^VolumeMountInfoHeader;
  66.     VolumeMountInfoHeader = RECORD
  67.         length:                    INTEGER;                                {  length of location data (including self)  }
  68.         media:                    VolumeType;                                {  type of media (must be registered with Apple)  }
  69.         flags:                    INTEGER;                                {  volume mount flags. Variable length data follows  }
  70.     END;
  71.  
  72.  
  73. CONST
  74.     gestaltFSMVersion            = 'fsm ';
  75.  
  76.  
  77. TYPE
  78.     VCBPtr                                = ^VCB;
  79. {$ENDC}
  80. {
  81.  * Miscellaneous file system values not in Files.h
  82. }
  83.  
  84. CONST
  85.     fsUsrCNID                    = 16;                            {  First assignable directory or file number  }
  86.                                                                 {     File system trap word attribute bits  }
  87.     kHFSBit                        = 9;                            {  HFS call: bit 9  }
  88.     kHFSMask                    = $0200;
  89.     kAsyncBit                    = 10;                            {  Asynchronous call: bit 10  }
  90.     kAsyncMask                    = $0400;
  91.  
  92. {
  93.  * HFSCIProc selectCode values
  94.  * Note: The trap attribute bits (the HFS bit and the asynchronous bit)
  95.  * may be set in these selectCode values.
  96. }
  97.     kFSMOpen                    = $A000;
  98.     kFSMClose                    = $A001;
  99.     kFSMRead                    = $A002;
  100.     kFSMWrite                    = $A003;
  101.     kFSMGetVolInfo                = $A007;
  102.     kFSMCreate                    = $A008;
  103.     kFSMDelete                    = $A009;
  104.     kFSMOpenRF                    = $A00A;
  105.     kFSMRename                    = $A00B;
  106.     kFSMGetFileInfo                = $A00C;
  107.     kFSMSetFileInfo                = $A00D;
  108.     kFSMUnmountVol                = $A00E;
  109.     kFSMMountVol                = $A00F;
  110.     kFSMAllocate                = $A010;
  111.     kFSMGetEOF                    = $A011;
  112.     kFSMSetEOF                    = $A012;
  113.     kFSMFlushVol                = $A013;
  114.     kFSMGetVol                    = $A014;
  115.     kFSMSetVol                    = $A015;
  116.     kFSMEject                    = $A017;
  117.     kFSMGetFPos                    = $A018;
  118.     kFSMOffline                    = $A035;
  119.     kFSMSetFilLock                = $A041;
  120.     kFSMRstFilLock                = $A042;
  121.     kFSMSetFilType                = $A043;
  122.     kFSMSetFPos                    = $A044;
  123.     kFSMFlushFile                = $A045;                        {     The File System HFSDispatch selectCodes  }
  124.     kFSMOpenWD                    = $0001;
  125.     kFSMCloseWD                    = $0002;
  126.     kFSMCatMove                    = $0005;
  127.     kFSMDirCreate                = $0006;
  128.     kFSMGetWDInfo                = $0007;
  129.     kFSMGetFCBInfo                = $0008;
  130.     kFSMGetCatInfo                = $0009;
  131.     kFSMSetCatInfo                = $000A;
  132.     kFSMSetVolInfo                = $000B;
  133.     kFSMLockRng                    = $0010;
  134.     kFSMUnlockRng                = $0011;
  135.     kFSMCreateFileIDRef            = $0014;
  136.     kFSMDeleteFileIDRef            = $0015;
  137.     kFSMResolveFileIDRef        = $0016;
  138.     kFSMExchangeFiles            = $0017;
  139.     kFSMCatSearch                = $0018;
  140.     kFSMOpenDF                    = $001A;
  141.     kFSMMakeFSSpec                = $001B;                        {     The Desktop Manager HFSDispatch selectCodes  }
  142.     kFSMDTGetPath                = $0020;
  143.     kFSMDTCloseDown                = $0021;
  144.     kFSMDTAddIcon                = $0022;
  145.     kFSMDTGetIcon                = $0023;
  146.     kFSMDTGetIconInfo            = $0024;
  147.     kFSMDTAddAPPL                = $0025;
  148.     kFSMDTRemoveAPPL            = $0026;
  149.     kFSMDTGetAPPL                = $0027;
  150.     kFSMDTSetComment            = $0028;
  151.     kFSMDTRemoveComment            = $0029;
  152.     kFSMDTGetComment            = $002A;
  153.     kFSMDTFlush                    = $002B;
  154.     kFSMDTReset                    = $002C;
  155.     kFSMDTGetInfo                = $002D;
  156.     kFSMDTOpenInform            = $002E;
  157.     kFSMDTDelete                = $002F;                        {     The AppleShare HFSDispatch selectCodes  }
  158.     kFSMGetVolParms                = $0030;
  159.     kFSMGetLogInInfo            = $0031;
  160.     kFSMGetDirAccess            = $0032;
  161.     kFSMSetDirAccess            = $0033;
  162.     kFSMMapID                    = $0034;
  163.     kFSMMapName                    = $0035;
  164.     kFSMCopyFile                = $0036;
  165.     kFSMMoveRename                = $0037;
  166.     kFSMOpenDeny                = $0038;
  167.     kFSMOpenRFDeny                = $0039;
  168.     kFSMGetXCatInfo                = $003A;
  169.     kFSMGetVolMountInfoSize        = $003F;
  170.     kFSMGetVolMountInfo            = $0040;
  171.     kFSMVolumeMount                = $0041;
  172.     kFSMShare                    = $0042;
  173.     kFSMUnShare                    = $0043;
  174.     kFSMGetUGEntry                = $0044;
  175.     kFSMGetForeignPrivs            = $0060;
  176.     kFSMSetForeignPrivs            = $0061;
  177.  
  178. {
  179.  * UTDetermineVol status values
  180. }
  181.     dtmvError                    = 0;                            {  param error  }
  182.     dtmvFullPathame                = 1;                            {  determined by full pathname  }
  183.     dtmvVRefNum                    = 2;                            {  determined by volume refNum  }
  184.     dtmvWDRefNum                = 3;                            {  determined by working directory refNum  }
  185.     dtmvDriveNum                = 4;                            {  determined by drive number  }
  186.     dtmvDefault                    = 5;                            {  determined by default volume  }
  187.  
  188. {
  189.  * UTGetBlock options
  190. }
  191.     gbDefault                    = 0;                            {  default value - read if not found  }
  192.                                                                 {     bits and masks  }
  193.     gbReadBit                    = 0;                            {  read block from disk (forced read)  }
  194.     gbReadMask                    = $0001;
  195.     gbExistBit                    = 1;                            {  get existing cache block  }
  196.     gbExistMask                    = $0002;
  197.     gbNoReadBit                    = 2;                            {  don't read block from disk if not found in cache  }
  198.     gbNoReadMask                = $0004;
  199.     gbReleaseBit                = 3;                            {  release block immediately after GetBlock  }
  200.     gbReleaseMask                = $0008;
  201.  
  202. {
  203.  * UTReleaseBlock options
  204. }
  205.     rbDefault                    = 0;                            {  default value - just mark the buffer not in-use  }
  206.                                                                 {     bits and masks  }
  207.     rbWriteBit                    = 0;                            {  force write buffer to disk  }
  208.     rbWriteMask                    = $0001;
  209.     rbTrashBit                    = 1;                            {  trash buffer contents after release  }
  210.     rbTrashMask                    = $0002;
  211.     rbDirtyBit                    = 2;                            {  mark buffer dirty  }
  212.     rbDirtyMask                    = $0004;
  213.     rbFreeBit                    = 3;                            {  free the buffer (save in the hash)  }
  214.     rbFreeMask                    = $000A;                        {  rbFreeMask (rbFreeBit + rbTrashBit) works as rbTrash on < System 7.0 RamCache; on >= System 7.0, rbfreeMask overrides rbTrash  }
  215.  
  216. {
  217.  * UTFlushCache options
  218. }
  219.     fcDefault                    = 0;                            {  default value - just flush any dirty buffers  }
  220.                                                                 {     bits and masks  }
  221.     fcTrashBit                    = 1;                            {  trash buffers after flushing  }
  222.     fcTrashMask                    = $0002;
  223.     fcFreeBit                    = 3;                            {  free buffers after flushing  }
  224.     fcFreeMask                    = $0008;                        {  fcFreeMask works as fcTrash on < System 7.0 RamCache  }
  225.  
  226. {
  227.  * UTCacheReadIP and UTCacheWriteIP cacheOption
  228. }
  229.     noCacheBit                    = 5;                            {  don't cache this please  }
  230.     noCacheMask                    = $0020;
  231.     rdVerifyBit                    = 6;                            {  read verify  }
  232.     rdVerifyMask                = $0040;
  233.  
  234. {
  235.  * Cache routine internal error codes
  236. }
  237.     chNoBuf                        = 1;                            {  no free cache buffers (all in use)  }
  238.     chInUse                        = 2;                            {  requested block in use  }
  239.     chnotfound                    = 3;                            {  requested block not found  }
  240.     chNotInUse                    = 4;                            {  block being released was not in use  }
  241.  
  242. {
  243.  * FCBRec.fcbFlags bits
  244. }
  245.     fcbWriteBit                    = 0;                            {  Data can be written to this file  }
  246.     fcbWriteMask                = $01;
  247.     fcbResourceBit                = 1;                            {  This file is a resource fork  }
  248.     fcbResourceMask                = $02;
  249.     fcbWriteLockedBit            = 2;                            {  File has a locked byte range  }
  250.     fcbWriteLockedMask            = $04;
  251.     fcbSharedWriteBit            = 4;                            {  File is open for shared write access  }
  252.     fcbSharedWriteMask            = $10;
  253.     fcbFileLockedBit            = 5;                            {  File is locked (write-protected)  }
  254.     fcbFileLockedMask            = $20;
  255.     fcbOwnClumpBit                = 6;                            {  File has clump size specified in FCB  }
  256.     fcbOwnClumpMask                = $40;
  257.     fcbModifiedBit                = 7;                            {  File has changed since it was last flushed  }
  258.     fcbModifiedMask                = $80;
  259.  
  260. {
  261.  * ExtFileProc options
  262. }
  263.     extendFileAllBit            = 0;                            {  allocate all requested bytes or none  }
  264.     extendFileAllMask            = $0001;
  265.     extendFileContigBit            = 1;                            {  force contiguous allocation  }
  266.     extendFileContigMask        = $0002;
  267.  
  268. {
  269.  *    HFS Component Interface constants
  270. }
  271. {
  272.  * compInterfMask bits specific to HFS component
  273. }
  274.     hfsCIDoesHFSBit                = 23;                            {  set if file system supports HFS calls  }
  275.     hfsCIDoesHFSMask            = $00800000;
  276.     hfsCIDoesAppleShareBit        = 22;                            {  set if AppleShare calls supported  }
  277.     hfsCIDoesAppleShareMask        = $00400000;
  278.     hfsCIDoesDeskTopBit            = 21;                            {  set if Desktop Database calls supported  }
  279.     hfsCIDoesDeskTopMask        = $00200000;
  280.     hfsCIDoesDynamicLoadBit        = 20;                            {  set if dynamically loading code resource  }
  281.     hfsCIDoesDynamicLoadMask    = $00100000;                    {         supported  }
  282.     hfsCIResourceLoadedBit        = 19;                            {  set if code resource already loaded  }
  283.     hfsCIResourceLoadedMask        = $00080000;
  284.     hfsCIHasHLL2PProcBit        = 18;                            {  set if FFS' log2PhyProc and Extendfile proc  }
  285.     hfsCIHasHLL2PProcMask        = $00040000;                    {  is written in a high level language. (i.e., uses Pascal calling convention)  }
  286.  
  287. {
  288.  *    Disk Initialization Component Interface constants
  289. }
  290. {
  291.  * compInterfMask bits specific to Disk Initialization component
  292. }
  293.     diCIHasExtFormatParamsBit    = 18;                            {  set if file system needs extended format  }
  294.     diCIHasExtFormatParamsMask    = $00040000;                    {         parameters  }
  295.     diCIHasMultiVolTypesBit        = 17;                            {  set if file system supports more than one  }
  296.     diCIHasMultiVolTypesMask    = $00020000;                    {         volume type  }
  297.     diCIDoesSparingBit            = 16;                            {  set if file system supports disk sparing  }
  298.     diCIDoesSparingMask            = $00010000;
  299.     diCILiveBit                    = 0;                            {  set if file system is candidate for current  }
  300.     diCILiveMask                = $00000001;                    {         formatting operation (set by PACK2)  }
  301.  
  302. {
  303.  * Disk Initialization Component Function selectors
  304. }
  305.     diCILoad                    = 1;                            {  Make initialization code memory resident  }
  306.     diCIUnload                    = 2;                            {  Make initialization code purgeable  }
  307.     diCIEvaluateSizeChoices        = 3;                            {  Evaluate size choices  }
  308.     diCIExtendedZero            = 4;                            {  Write an empty volume directory  }
  309.     diCIValidateVolName            = 5;                            {  Validate volume name  }
  310.     diCIGetVolTypeInfo            = 6;                            {  get volume type info  }
  311.     diCIGetFormatString            = 7;                            {  get dialog format string  }
  312.     diCIGetExtFormatParams        = 8;                            {  get extended format parameters  }
  313.     diCIGetDefectList            = 9;                            {  return the defect list for the indicated disk - reserved for future use  }
  314.  
  315. {
  316.  * Constants used in the DICIEvaluateSizeRec and FormatListRec
  317. }
  318.     diCIFmtListMax                = 8;                            {  maximum number of format list entries in DICIEvaluateSizeRec.numSizeEntries  }
  319.                                                                 {     bits in FormatListRec.formatFlags:  }
  320.     diCIFmtFlagsValidBit        = 7;                            {  set if sec, side, tracks valid  }
  321.     diCIFmtFlagsValidMask        = $80;
  322.     diCIFmtFlagsCurrentBit        = 6;                            {  set if current disk has this fmt  }
  323.     diCIFmtFlagsCurrentMask        = $40;                            {     bits in FormatListRec.sizeListFlags:  }
  324.     diCISizeListOKBit            = 15;                            {  set if this disk size usable  }
  325.     diCISizeListOKMask            = $8000;
  326.  
  327. {
  328.  * DICIGetFormatStringRec.stringKind format strings
  329. }
  330.     diCIAlternateFormatStr        = 1;                            {  get alternate format  string (Balloon Help)  }
  331.     diCISizePresentationStr        = 2;                            {  get size presentation string (for dialog)  }
  332.  
  333. {
  334.  * Error codes returned by Disk Sparing
  335. }
  336.     diCIUserCancelErr            = 1;                            {  user cancelled the disk init  }
  337.     diCICriticalSectorBadErr    = 20;                            {  critical sectors are bad (hopeless)     }
  338.     diCISparingFailedErr        = 21;                            {  disk cannot be spared  }
  339.     diCITooManyBadSectorsErr    = 22;                            {  too many bad sectors  }
  340.     diCIUnknownVolTypeErr        = 23;                            {  the volume type passed in diCIExtendedZero paramBlock is not supported  }
  341.     diCIVolSizeMismatchErr        = 24;                            {  specified volume size doesn't match with formatted disk size  }
  342.     diCIUnknownDICallErr        = 25;                            {  bogus DI function call selector  }
  343.     diCINoSparingErr            = 26;                            {  disk is bad but the target FS doesn't do disk sparing  }
  344.     diCINoExtendInfoErr            = 27;                            {  missing file system specific extra parameter in diCIExtendedZero call  }
  345.     diCINoMessageTextErr        = 28;                            {  missing message text in DIReformat call  }
  346.  
  347. {
  348.  *    File System Manager constants
  349. }
  350. {
  351.  * Miscellaneous constants used by FSM
  352. }
  353.     fsdVersion1                    = 1;                            {  current version of FSD record  }
  354.     fsmIgnoreFSID                = $FFFE;                        {  this FSID should be ignored by the driver  }
  355.     fsmGenericFSID                = $FFFF;                        {  unknown foreign file system ID  }
  356.  
  357. {
  358.  * compInterfMask bits common to all FSM components
  359. }
  360.     fsmComponentEnableBit        = 31;                            {  set if FSM component interface is enabled  }
  361.     fsmComponentEnableMask        = $80000000;
  362.     fsmComponentBusyBit            = 30;                            {  set if FSM component interface is busy  }
  363.     fsmComponentBusyMask        = $40000000;
  364.  
  365. {
  366.  * Selectors for GetFSInfo
  367. }
  368.     fsmGetFSInfoByIndex            = -1;                            {  get fs info by index  }
  369.     fsmGetFSInfoByFSID            = 0;                            {  get fs info by FSID  }
  370.     fsmGetFSInfoByRefNum        = 1;                            {  get fs info by file/vol refnum  }
  371.  
  372. {
  373.  * InformFSM messages
  374. }
  375.     fsmNopMessage                = 0;                            {  nop  }
  376.     fsmDrvQElChangedMessage        = 1;                            {  DQE has changed  }
  377.     fsmGetFSIconMessage            = 2;                            {  Get FFS's disk icon  }
  378.  
  379. {
  380.  * Messages passed to the fileSystemCommProc
  381. }
  382.     ffsNopMessage                = 0;                            {  nop, should always return noErr  }
  383.     ffsGetIconMessage            = 1;                            {  return disk icon and mask  }
  384.     ffsIDDiskMessage            = 2;                            {  identify the about-to-be-mounted volume  }
  385.     ffsLoadMessage                = 3;                            {  load in the FFS  }
  386.     ffsUnloadMessage            = 4;                            {  unload the FFS  }
  387.     ffsIDVolMountMessage        = 5;                            {  identify a VolMountInfo record  }
  388.     ffsInformMessage            = 6;                            {  FFS defined message  }
  389.     ffsGetIconInfoMessage        = 7;
  390.  
  391. {
  392.  * Error codes from FSM functions
  393. }
  394.     fsmFFSNotFoundErr            = -431;                            {  Foreign File system does not exist - new Pack2 could return this error too  }
  395.     fsmBusyFFSErr                = -432;                            {  File system is busy, cannot be removed  }
  396.     fsmBadFFSNameErr            = -433;                            {  Name length not 1 <= length <= 31  }
  397.     fsmBadFSDLenErr                = -434;                            {  FSD size incompatible with current FSM vers  }
  398.     fsmDuplicateFSIDErr            = -435;                            {  FSID already exists on InstallFS  }
  399.     fsmBadFSDVersionErr            = -436;                            {  FSM version incompatible with FSD  }
  400.     fsmNoAlternateStackErr        = -437;                            {  no alternate stack for HFS CI  }
  401.     fsmUnknownFSMMessageErr        = -438;                            {  unknown message passed to FSM  }
  402.  
  403. {
  404.  *    HFS Utility routine records
  405. }
  406. {
  407.  * record used by UTGetPathComponentName
  408. }
  409.  
  410. TYPE
  411.     ParsePathRecPtr = ^ParsePathRec;
  412.     ParsePathRec = RECORD
  413.         namePtr:                StringPtr;                                {  pathname to parse  }
  414.         startOffset:            INTEGER;                                {  where to start parsing  }
  415.         componentLength:        INTEGER;                                {  the length of the pathname component parsed  }
  416.         moreName:                SignedByte;                                {  non-zero if there are more components after this one  }
  417.         foundDelimiter:            SignedByte;                                {  non-zero if parsing stopped because a colon (:) delimiter was found  }
  418.     END;
  419.  
  420.     WDCBRecPtr = ^WDCBRec;
  421.     WDCBRec = RECORD
  422.         wdVCBPtr:                VCBPtr;                                    {  Pointer to VCB of this working directory  }
  423.         wdDirID:                LONGINT;                                {  Directory ID number of this working directory  }
  424.         wdCatHint:                LONGINT;                                {  Hint for finding this working directory  }
  425.         wdProcID:                LONGINT;                                {  Process that created this working directory  }
  426.     END;
  427.  
  428.     FCBRecPtr = ^FCBRec;
  429.     FCBRec = RECORD
  430.         fcbFlNm:                LONGINT;                                {  FCB file number. Non-zero marks FCB used  }
  431.         fcbFlags:                SignedByte;                                {  FCB flags  }
  432.         fcbTypByt:                SignedByte;                                {  File type byte  }
  433.         fcbSBlk:                INTEGER;                                {  File start block (in alloc size blks)  }
  434.         fcbEOF:                    LONGINT;                                {  Logical length or EOF in bytes  }
  435.         fcbPLen:                LONGINT;                                {  Physical file length in bytes  }
  436.         fcbCrPs:                LONGINT;                                {  Current position within file  }
  437.         fcbVPtr:                VCBPtr;                                    {  Pointer to the corresponding VCB  }
  438.         fcbBfAdr:                Ptr;                                    {  File's buffer address  }
  439.         fcbFlPos:                INTEGER;                                {  Directory block this file is in  }
  440.                                                                         {  FCB Extensions for HFS  }
  441.         fcbClmpSize:            LONGINT;                                {  Number of bytes per clump  }
  442.         fcbBTCBPtr:                Ptr;                                    {  Pointer to B*-Tree control block for file  }
  443.         fcbExtRec:                ARRAY [0..2] OF LONGINT;                {  First 3 file extents  }
  444.         fcbFType:                OSType;                                    {  File's 4 Finder Type bytes  }
  445.         fcbCatPos:                LONGINT;                                {  Catalog hint for use on Close  }
  446.         fcbDirID:                LONGINT;                                {  Parent Directory ID  }
  447.         fcbCName:                Str31;                                    {  CName of open file  }
  448.     END;
  449.  
  450. {
  451.  *    HFS Component Interface records
  452. }
  453.     Lg2PhysProcPtr = ProcPtr;  { FUNCTION Lg2Phys(fsdGlobalPtr: UNIV Ptr; volCtrlBlockPtr: VCBPtr; fileCtrlBlockPtr: FCBRecPtr; fileRefNum: INTEGER; filePosition: LONGINT; reqCount: LONGINT; VAR volOffset: LONGINT; VAR contiguousBytes: LONGINT): OSErr; }
  454.  
  455.     Lg2PhysUPP = UniversalProcPtr;
  456.  
  457. CONST
  458.     uppLg2PhysProcInfo = $003FEFE0;
  459.  
  460. FUNCTION NewLg2PhysProc(userRoutine: Lg2PhysProcPtr): Lg2PhysUPP;
  461.     {$IFC NOT GENERATINGCFM }
  462.     INLINE $2E9F;
  463.     {$ENDC}
  464.  
  465. FUNCTION CallLg2PhysProc(fsdGlobalPtr: UNIV Ptr; volCtrlBlockPtr: VCBPtr; fileCtrlBlockPtr: FCBRecPtr; fileRefNum: INTEGER; filePosition: LONGINT; reqCount: LONGINT; VAR volOffset: LONGINT; VAR contiguousBytes: LONGINT; userRoutine: Lg2PhysUPP): OSErr;
  466.     {$IFC NOT GENERATINGCFM}
  467.     INLINE $205F, $4E90;
  468.     {$ENDC}
  469.  
  470. TYPE
  471.     HFSCIProcPtr = ProcPtr;  { FUNCTION HFSCI(theVCB: VCBPtr; selectCode: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; fsid: INTEGER): OSErr; }
  472.  
  473.     HFSCIUPP = UniversalProcPtr;
  474.  
  475. CONST
  476.     uppHFSCIProcInfo = $0000BEE0;
  477.  
  478. FUNCTION NewHFSCIProc(userRoutine: HFSCIProcPtr): HFSCIUPP;
  479.     {$IFC NOT GENERATINGCFM }
  480.     INLINE $2E9F;
  481.     {$ENDC}
  482.  
  483. FUNCTION CallHFSCIProc(theVCB: VCBPtr; selectCode: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; fsid: INTEGER; userRoutine: HFSCIUPP): OSErr;
  484.     {$IFC NOT GENERATINGCFM}
  485.     INLINE $205F, $4E90;
  486.     {$ENDC}
  487.  
  488. TYPE
  489.     HFSCIRecPtr = ^HFSCIRec;
  490.     HFSCIRec = RECORD
  491.         compInterfMask:            LONGINT;                                {  component flags  }
  492.         compInterfProc:            HFSCIProcPtr;                            {  pointer to file system call processing code  }
  493.         log2PhyProc:            Lg2PhysProcPtr;                            {  pointer to Lg2PhysProc() code  }
  494.         stackTop:                Ptr;                                    {  file system stack top  }
  495.         stackSize:                LONGINT;                                {  file system stack size  }
  496.         stackPtr:                Ptr;                                    {  current file system stack pointer  }
  497.         reserved3:                LONGINT;                                {  --reserved, must be zero--  }
  498.         idSector:                LONGINT;                                {  Sector you need to ID a local volume. For networked volumes, this must be -1  }
  499.         reserved2:                LONGINT;                                {  --reserved, must be zero--  }
  500.         reserved1:                LONGINT;                                {  --reserved, must be zero--  }
  501.     END;
  502.  
  503. {
  504.  *    Disk Initialization Component Interface records
  505. }
  506.     DICIProcPtr = ProcPtr;  { FUNCTION DICI(whatFunction: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr): OSErr; }
  507.  
  508.     DICIUPP = UniversalProcPtr;
  509.  
  510. CONST
  511.     uppDICIProcInfo = $00000FA0;
  512.  
  513. FUNCTION NewDICIProc(userRoutine: DICIProcPtr): DICIUPP;
  514.     {$IFC NOT GENERATINGCFM }
  515.     INLINE $2E9F;
  516.     {$ENDC}
  517.  
  518. FUNCTION CallDICIProc(whatFunction: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; userRoutine: DICIUPP): OSErr;
  519.     {$IFC NOT GENERATINGCFM}
  520.     INLINE $205F, $4E90;
  521.     {$ENDC}
  522.  
  523. TYPE
  524.     DICIRecPtr = ^DICIRec;
  525.     DICIRec = RECORD
  526.         compInterfMask:            LONGINT;                                {  component flags  }
  527.         compInterfProc:            DICIProcPtr;                            {  pointer to call processing code  }
  528.         maxVolNameLength:        INTEGER;                                {  maximum length of your volume name  }
  529.         blockSize:                INTEGER;                                {  your file system's block size  }
  530.         reserved3:                LONGINT;                                {  --reserved, must be zero--  }
  531.         reserved2:                LONGINT;                                {  --reserved, must be zero--  }
  532.         reserved1:                LONGINT;                                {  --reserved, must be zero--  }
  533.     END;
  534.  
  535. {
  536.  * FormatListRec as returned by the .Sony disk driver's
  537.  * Return Format List status call (csCode = 6).
  538.  * If the status call to get this list for a drive is not
  539.  * implemented by the driver, then a list with one entry
  540.  * is contructed from the drive queue element for the drive.
  541. }
  542.     FormatListRecPtr = ^FormatListRec;
  543.     FormatListRec = RECORD
  544.         volSize:                LONGINT;                                {  disk capacity in SECTORs  }
  545.         formatFlags:            SignedByte;                                {  flags  }
  546.         sectorsPerTrack:        SignedByte;                                {  sectors per track side  }
  547.         tracks:                    INTEGER;                                {  number of tracks  }
  548.     END;
  549.  
  550. {
  551.  * SizeListRec built from FormatListRecs as described above.
  552. }
  553.     SizeListRecPtr = ^SizeListRec;
  554.     SizeListRec = RECORD
  555.         sizeListFlags:            INTEGER;                                {  flags as set by external file system  }
  556.         sizeEntry:                FormatListRec;                            {  disk driver format list record  }
  557.     END;
  558.  
  559. {
  560.  * paramBlock for the diCIEvaluateSize call
  561. }
  562.     DICIEvaluateSizeRecPtr = ^DICIEvaluateSizeRec;
  563.     DICIEvaluateSizeRec = RECORD
  564.         defaultSizeIndex:        INTEGER;                                {  default size for this FS  }
  565.         numSizeEntries:            INTEGER;                                {  number of size entries  }
  566.         driveNumber:            INTEGER;                                {  drive number  }
  567.         sizeListPtr:            SizeListRecPtr;                            {  ptr to size entry table  }
  568.         sectorSize:                INTEGER;                                {  bytes per sector  }
  569.     END;
  570.  
  571. {
  572.  * paramBlock for the diCIExtendedZero call
  573. }
  574.     DICIExtendedZeroRecPtr = ^DICIExtendedZeroRec;
  575.     DICIExtendedZeroRec = RECORD
  576.         driveNumber:            INTEGER;                                {  drive number  }
  577.         volNamePtr:                StringPtr;                                {  ptr to volume name string  }
  578.         fsid:                    INTEGER;                                {  file system ID  }
  579.         volTypeSelector:        INTEGER;                                {  volume type selector, if supports more than 1 type  }
  580.         numDefectBlocks:        INTEGER;                                {  number of bad logical blocks  }
  581.         defectListSize:            INTEGER;                                {  size of the defect list buffer in bytes  }
  582.         defectListPtr:            Ptr;                                    {  pointer to defect list buffer  }
  583.         volSize:                LONGINT;                                {  size of volume in SECTORs  }
  584.         sectorSize:                INTEGER;                                {  bytes per sector  }
  585.         extendedInfoPtr:        Ptr;                                    {  ptr to extended info  }
  586.     END;
  587.  
  588. {
  589.  * paramBlock for the diCIValidateVolName call
  590. }
  591.     DICIValidateVolNameRecPtr = ^DICIValidateVolNameRec;
  592.     DICIValidateVolNameRec = PACKED RECORD
  593.         theChar:                CHAR;                                    {  the character to validate  }
  594.         hasMessageBuffer:        BOOLEAN;                                {  false if no message  }
  595.         charOffset:                INTEGER;                                {  position of the current character (first char = 1)  }
  596.         messageBufferPtr:        StringPtr;                                {  pointer to message buffer or nil  }
  597.         charByteType:            INTEGER;                                {  theChar's byte type (smSingleByte, smFirstByte, or smLastByte)  }
  598.     END;
  599.  
  600. {
  601.  * paramBlock for the diCIGetVolTypeInfo call
  602. }
  603.     DICIGetVolTypeInfoRecPtr = ^DICIGetVolTypeInfoRec;
  604.     DICIGetVolTypeInfoRec = RECORD
  605.         volSize:                LONGINT;                                {  size of volume in SECTORs  }
  606.         sectorSize:                INTEGER;                                {  bytes per sector  }
  607.         numVolTypes:            INTEGER;                                {  number of volume types supported  }
  608.         volTypesBuffer:            ARRAY [0..3] OF Str31;                    {  4 string buffers  }
  609.     END;
  610.  
  611. {
  612.  * paramBlock for the diCIGetFormatString call
  613. }
  614.     DICIGetFormatStringRecPtr = ^DICIGetFormatStringRec;
  615.     DICIGetFormatStringRec = RECORD
  616.         volSize:                LONGINT;                                {  volume size in SECTORs  }
  617.         sectorSize:                INTEGER;                                {  sector size  }
  618.         volTypeSelector:        INTEGER;                                {  volume type selector  }
  619.         stringKind:                INTEGER;                                {  sub-function = type of string  }
  620.         stringBuffer:            Str255;                                    {  string buffer  }
  621.     END;
  622.  
  623. {
  624.  * paramBlock for the diCIGetExtendedFormatParams call
  625. }
  626.     DICIGetExtendedFormatRecPtr = ^DICIGetExtendedFormatRec;
  627.     DICIGetExtendedFormatRec = RECORD
  628.         driveNumber:            INTEGER;                                {  drive number  }
  629.         volTypeSelector:        INTEGER;                                {  volume type selector or 0  }
  630.         volSize:                LONGINT;                                {  size of volume in SECTORs  }
  631.         sectorSize:                INTEGER;                                {  bytes per sector  }
  632.         fileSystemSpecPtr:        FSSpecPtr;                                {  pointer to the foreign file system's FSSpec  }
  633.         extendedInfoPtr:        Ptr;                                    {  pointer to extended parameter structure  }
  634.     END;
  635.  
  636. {
  637.  *    File System Manager records
  638. }
  639.     FSDCommProcPtr = ProcPtr;  { FUNCTION FSDComm(message: INTEGER; paramBlock: UNIV Ptr; globalsPtr: UNIV Ptr): OSErr; }
  640.  
  641.     FSDCommUPP = UniversalProcPtr;
  642.  
  643. CONST
  644.     uppFSDCommProcInfo = $00000FA0;
  645.  
  646. FUNCTION NewFSDCommProc(userRoutine: FSDCommProcPtr): FSDCommUPP;
  647.     {$IFC NOT GENERATINGCFM }
  648.     INLINE $2E9F;
  649.     {$ENDC}
  650.  
  651. FUNCTION CallFSDCommProc(message: INTEGER; paramBlock: UNIV Ptr; globalsPtr: UNIV Ptr; userRoutine: FSDCommUPP): OSErr;
  652.     {$IFC NOT GENERATINGCFM}
  653.     INLINE $205F, $4E90;
  654.     {$ENDC}
  655.  
  656. TYPE
  657.     FSDRecPtr = ^FSDRec;
  658.     FSDRec = RECORD
  659.         fsdLink:                FSDRecPtr;                                {  ptr to next  }
  660.         fsdLength:                INTEGER;                                {  length of this FSD in BYTES  }
  661.         fsdVersion:                INTEGER;                                {  version number  }
  662.         fileSystemFSID:            INTEGER;                                {  file system id  }
  663.         fileSystemName:            Str31;                                    {  file system name  }
  664.         fileSystemSpec:            FSSpec;                                    {  foreign file system's FSSpec  }
  665.         fileSystemGlobalsPtr:    Ptr;                                    {  ptr to file system globals  }
  666.         fileSystemCommProc:        FSDCommProcPtr;                            {  communication proc with the FFS  }
  667.         reserved3:                LONGINT;                                {  --reserved, must be zero--  }
  668.         reserved2:                LONGINT;                                {  --reserved, must be zero--  }
  669.         reserved1:                LONGINT;                                {  --reserved, must be zero--  }
  670.         fsdHFSCI:                HFSCIRec;                                {  HFS component interface     }
  671.         fsdDICI:                DICIRec;                                {  Disk Initialization component interface  }
  672.     END;
  673.  
  674.     FSMGetIconInfoRecPtr = ^FSMGetIconInfoRec;
  675.     FSMGetIconInfoRec = RECORD
  676.         theIcon:                ARRAY [0..31] OF LONGINT;                {  The ICN# structure  }
  677.         theMask:                ARRAY [0..31] OF LONGINT;                {  The mask for the icon above  }
  678.         whereStr:                Str255;
  679.     END;
  680.  
  681. {
  682.  * paramBlock for ffsGetIconMessage and fsmGetFSIconMessage
  683. }
  684.     FSMGetIconRecPtr = ^FSMGetIconRec;
  685.     FSMGetIconRec = RECORD
  686.         refNum:                    INTEGER;                                {  target drive num or volume refnum  }
  687.         iconBufferPtr:            FSMGetIconInfoRecPtr;                    {  pointer to icon buffer  }
  688.         requestSize:            LONGINT;                                {  requested size of the icon buffer  }
  689.         actualSize:                LONGINT;                                {  actual size of the icon data returned  }
  690.         iconType:                SInt8;                                    {  kind of icon  }
  691.         isEjectable:            BOOLEAN;                                {  true if the device is ejectable  }
  692.         driveQElemPtr:            DrvQElPtr;                                {  pointer to DQE  }
  693.         fileSystemSpecPtr:        FSSpecPtr;                                {  pointer to foreign file system's FSSpec  }
  694.         reserved1:                LONGINT;                                {  --reserved, must be zero--  }
  695.     END;
  696.  
  697. {
  698.  *    HFS Utility routine prototypes
  699. }
  700. FUNCTION UTAllocateFCB(VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  701.     {$IFC NOT GENERATINGCFM}
  702.     INLINE $7000, $A824;
  703.     {$ENDC}
  704. FUNCTION UTReleaseFCB(fileRefNum: INTEGER): OSErr;
  705.     {$IFC NOT GENERATINGCFM}
  706.     INLINE $7001, $A824;
  707.     {$ENDC}
  708. FUNCTION UTLocateFCB(volCtrlBlockPtr: VCBPtr; fileNum: LONGINT; namePtr: StringPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  709.     {$IFC NOT GENERATINGCFM}
  710.     INLINE $7002, $A824;
  711.     {$ENDC}
  712. FUNCTION UTLocateNextFCB(volCtrlBlockPtr: VCBPtr; fileNum: LONGINT; namePtr: StringPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  713.     {$IFC NOT GENERATINGCFM}
  714.     INLINE $7003, $A824;
  715.     {$ENDC}
  716. FUNCTION UTIndexFCB(volCtrlBlockPtr: VCBPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  717.     {$IFC NOT GENERATINGCFM}
  718.     INLINE $7004, $A824;
  719.     {$ENDC}
  720. FUNCTION UTResolveFCB(fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  721.     {$IFC NOT GENERATINGCFM}
  722.     INLINE $7005, $A824;
  723.     {$ENDC}
  724. FUNCTION UTAllocateVCB(VAR sysVCBLength: INTEGER; VAR volCtrlBlockPtr: VCBPtr; addSize: INTEGER): OSErr;
  725.     {$IFC NOT GENERATINGCFM}
  726.     INLINE $7006, $A824;
  727.     {$ENDC}
  728. FUNCTION UTAddNewVCB(driveNum: INTEGER; VAR vRefNum: INTEGER; volCtrlBlockPtr: VCBPtr): OSErr;
  729.     {$IFC NOT GENERATINGCFM}
  730.     INLINE $7007, $A824;
  731.     {$ENDC}
  732. FUNCTION UTDisposeVCB(volCtrlBlockPtr: VCBPtr): OSErr;
  733.     {$IFC NOT GENERATINGCFM}
  734.     INLINE $7008, $A824;
  735.     {$ENDC}
  736. FUNCTION UTLocateVCBByRefNum(refNum: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  737.     {$IFC NOT GENERATINGCFM}
  738.     INLINE $7009, $A824;
  739.     {$ENDC}
  740. FUNCTION UTLocateVCBByName(namePtr: StringPtr; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  741.     {$IFC NOT GENERATINGCFM}
  742.     INLINE $700A, $A824;
  743.     {$ENDC}
  744. FUNCTION UTLocateNextVCB(namePtr: StringPtr; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  745.     {$IFC NOT GENERATINGCFM}
  746.     INLINE $700B, $A824;
  747.     {$ENDC}
  748. FUNCTION UTAllocateWDCB(paramBlock: WDPBPtr): OSErr;
  749.     {$IFC NOT GENERATINGCFM}
  750.     INLINE $700C, $A824;
  751.     {$ENDC}
  752. FUNCTION UTReleaseWDCB(wdRefNum: INTEGER): OSErr;
  753.     {$IFC NOT GENERATINGCFM}
  754.     INLINE $700D, $A824;
  755.     {$ENDC}
  756. FUNCTION UTResolveWDCB(procID: LONGINT; wdIndex: INTEGER; wdRefNum: INTEGER; VAR wdCtrlBlockPtr: WDCBRecPtr): OSErr;
  757.     {$IFC NOT GENERATINGCFM}
  758.     INLINE $700E, $A824;
  759.     {$ENDC}
  760. FUNCTION UTFindDrive(driveNum: INTEGER; VAR driveQElementPtr: DrvQElPtr): OSErr;
  761.     {$IFC NOT GENERATINGCFM}
  762.     INLINE $700F, $A824;
  763.     {$ENDC}
  764. FUNCTION UTAdjustEOF(fileRefNum: INTEGER): OSErr;
  765.     {$IFC NOT GENERATINGCFM}
  766.     INLINE $7010, $A824;
  767.     {$ENDC}
  768. FUNCTION UTSetDefaultVol(nodeHint: LONGINT; dirID: LONGINT; refNum: INTEGER): OSErr;
  769.     {$IFC NOT GENERATINGCFM}
  770.     INLINE $7011, $A824;
  771.     {$ENDC}
  772. FUNCTION UTGetDefaultVol(paramBlock: WDPBPtr): OSErr;
  773.     {$IFC NOT GENERATINGCFM}
  774.     INLINE $7012, $A824;
  775.     {$ENDC}
  776. FUNCTION UTEjectVol(volCtrlBlockPtr: VCBPtr): OSErr;
  777.     {$IFC NOT GENERATINGCFM}
  778.     INLINE $702B, $A824;
  779.     {$ENDC}
  780. FUNCTION UTCheckWDRefNum(wdRefNum: INTEGER): OSErr;
  781.     {$IFC NOT GENERATINGCFM}
  782.     INLINE $7013, $A824;
  783.     {$ENDC}
  784. FUNCTION UTCheckFileRefNum(fileRefNum: INTEGER): OSErr;
  785.     {$IFC NOT GENERATINGCFM}
  786.     INLINE $7014, $A824;
  787.     {$ENDC}
  788. FUNCTION UTCheckVolRefNum(vRefNum: INTEGER): OSErr;
  789.     {$IFC NOT GENERATINGCFM}
  790.     INLINE $7015, $A824;
  791.     {$ENDC}
  792. FUNCTION UTCheckPermission(volCtrlBlockPtr: VCBPtr; VAR modByte: INTEGER; fileNum: LONGINT; paramBlock: ParmBlkPtr): OSErr;
  793.     {$IFC NOT GENERATINGCFM}
  794.     INLINE $7016, $A824;
  795.     {$ENDC}
  796. FUNCTION UTCheckVolOffline(vRefNum: INTEGER): OSErr;
  797.     {$IFC NOT GENERATINGCFM}
  798.     INLINE $7017, $A824;
  799.     {$ENDC}
  800. FUNCTION UTCheckVolModifiable(vRefNum: INTEGER): OSErr;
  801.     {$IFC NOT GENERATINGCFM}
  802.     INLINE $7018, $A824;
  803.     {$ENDC}
  804. FUNCTION UTCheckFileModifiable(fileRefNum: INTEGER): OSErr;
  805.     {$IFC NOT GENERATINGCFM}
  806.     INLINE $7019, $A824;
  807.     {$ENDC}
  808. FUNCTION UTCheckDirBusy(volCtrlBlockPtr: VCBPtr; dirID: LONGINT): OSErr;
  809.     {$IFC NOT GENERATINGCFM}
  810.     INLINE $701A, $A824;
  811.     {$ENDC}
  812. FUNCTION UTParsePathname(VAR volNamelength: INTEGER; namePtr: StringPtr): OSErr;
  813.     {$IFC NOT GENERATINGCFM}
  814.     INLINE $701B, $A824;
  815.     {$ENDC}
  816. FUNCTION UTGetPathComponentName(parseRec: ParsePathRecPtr): OSErr;
  817.     {$IFC NOT GENERATINGCFM}
  818.     INLINE $701C, $A824;
  819.     {$ENDC}
  820. FUNCTION UTDetermineVol(paramBlock: ParmBlkPtr; VAR status: INTEGER; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  821.     {$IFC NOT GENERATINGCFM}
  822.     INLINE $701D, $A824;
  823.     {$ENDC}
  824. FUNCTION UTGetBlock(refNum: INTEGER; log2PhyProc: UNIV Ptr; blockNum: LONGINT; gbOption: INTEGER; VAR buffer: Ptr): OSErr;
  825.     {$IFC NOT GENERATINGCFM}
  826.     INLINE $701F, $A824;
  827.     {$ENDC}
  828. FUNCTION UTReleaseBlock(buffer: Ptr; rbOption: INTEGER): OSErr;
  829.     {$IFC NOT GENERATINGCFM}
  830.     INLINE $7020, $A824;
  831.     {$ENDC}
  832. FUNCTION UTFlushCache(refNum: INTEGER; fcOption: INTEGER): OSErr;
  833.     {$IFC NOT GENERATINGCFM}
  834.     INLINE $7021, $A824;
  835.     {$ENDC}
  836. FUNCTION UTMarkDirty(buffer: Ptr): OSErr;
  837.     {$IFC NOT GENERATINGCFM}
  838.     INLINE $7023, $A824;
  839.     {$ENDC}
  840. FUNCTION UTTrashVolBlocks(volCtrlBlockPtr: VCBPtr): OSErr;
  841.     {$IFC NOT GENERATINGCFM}
  842.     INLINE $7024, $A824;
  843.     {$ENDC}
  844. FUNCTION UTTrashFileBlocks(volCtrlBlockPtr: VCBPtr; fileNum: LONGINT): OSErr;
  845.     {$IFC NOT GENERATINGCFM}
  846.     INLINE $7025, $A824;
  847.     {$ENDC}
  848. FUNCTION UTTrashBlocks(beginPosition: LONGINT; byteCount: LONGINT; volCtrlBlockPtr: VCBPtr; fileRefNum: INTEGER; tbOption: INTEGER): OSErr;
  849.     {$IFC NOT GENERATINGCFM}
  850.     INLINE $7026, $A824;
  851.     {$ENDC}
  852. FUNCTION UTCacheReadIP(log2PhyProc: UNIV Ptr; filePosition: LONGINT; ioBuffer: Ptr; fileRefNum: INTEGER; reqCount: LONGINT; VAR actCount: LONGINT; cacheOption: INTEGER): OSErr;
  853.     {$IFC NOT GENERATINGCFM}
  854.     INLINE $7027, $A824;
  855.     {$ENDC}
  856. FUNCTION UTCacheWriteIP(log2PhyProc: UNIV Ptr; filePosition: LONGINT; ioBuffer: Ptr; fileRefNum: INTEGER; reqCount: LONGINT; VAR actCount: LONGINT; cacheOption: INTEGER): OSErr;
  857.     {$IFC NOT GENERATINGCFM}
  858.     INLINE $7028, $A824;
  859.     {$ENDC}
  860. FUNCTION UTBlockInFQHashP(vRefNum: INTEGER; diskBlock: LONGINT): OSErr;
  861.     {$IFC NOT GENERATINGCFM}
  862.     INLINE $702C, $A824;
  863.     {$ENDC}
  864. {
  865.  *    File System Manager call prototypes
  866. }
  867. FUNCTION InstallFS(fsdPtr: FSDRecPtr): OSErr;
  868. FUNCTION RemoveFS(fsid: INTEGER): OSErr;
  869. FUNCTION SetFSInfo(fsid: INTEGER; bufSize: INTEGER; fsdPtr: FSDRecPtr): OSErr;
  870. FUNCTION GetFSInfo(selector: INTEGER; key: INTEGER; VAR bufSize: INTEGER; fsdPtr: FSDRecPtr): OSErr;
  871. FUNCTION InformFSM(theMessage: INTEGER; paramBlock: UNIV Ptr): OSErr;
  872. FUNCTION InformFFS(fsid: INTEGER; paramBlock: UNIV Ptr): OSErr;
  873. {$ENDC}
  874. {$ALIGN RESET}
  875. {$POP}
  876.  
  877. {$SETC UsingIncludes := FSMIncludes}
  878.  
  879. {$ENDC} {__FSM__}
  880.  
  881. {$IFC NOT UsingIncludes}
  882.  END.
  883. {$ENDC}
  884.